package btc.backend.servicios;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import btc.backend.process.ConnectionFactory;
import btc.model.ClasificacionPallet;
import btc.model.Pallet;

public class PalletAppl {

	/**
	 * Retorna el pallet que corresponda al id pasado
	 * @param idPallet
	 * @return
	 */
	public Pallet obtenerPalletPorId(int idPallet){
		
		Pallet pallet = null;
		try {
			PreparedStatement getPalletSt = ConnectionFactory.getConnection().
							prepareStatement("select ID, FECHA_PROCESO,CLASIFICACION,ID_MAQUINA from pallet where ID = ?");
			
			getPalletSt.setInt(1, idPallet);
			ResultSet r = getPalletSt.executeQuery();

			while(r.next()){
				pallet = new Pallet(idPallet,r.getDate(2),r.getString(3),r.getInt(4));
			}
			r.close();
		
		}catch (SQLException e) {
			e.printStackTrace();
		}
		
		return pallet;
	}
	
	
	public List<Pallet> obtenerPallets(){
				
		List<Pallet> pallets = new ArrayList<Pallet>();
		try {
			PreparedStatement getPalletsSt = ConnectionFactory.getConnection().
							prepareStatement("select ID, FECHA_PROCESO,CLASIFICACION,ID_MAQUINA from pallet order by ID");
					
			ResultSet r = getPalletsSt.executeQuery();

			while(r.next()){
				pallets.add(new Pallet(r.getInt(1),r.getDate(2),r.getString(3),r.getInt(4)));
			}
			r.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return pallets;
	}
	

	public List<Pallet> obtenerPalletsPorClasificacion(String clasificacion){
		
		List<Pallet> pallets = new ArrayList<Pallet>();
		try {
			PreparedStatement getPalletsSt = ConnectionFactory.getConnection().
							prepareStatement("select ID, FECHA_PROCESO,CLASIFICACION,ID_MAQUINA from pallet" +
													" where CLASIFICACION = ? order by ID");
					
			getPalletsSt.setString(1, clasificacion);
			
			ResultSet r = getPalletsSt.executeQuery();

			while(r.next()){
				pallets.add(new Pallet(r.getInt(1),r.getDate(2),r.getString(3),r.getInt(4)));
			}
			r.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return pallets;
	}

	public Map<String, Float> obtenerPalletsPorClasificacion(){
		
		List<Pallet> pallets = obtenerPallets();
		
		int cantidadPrimera = 0;
		int cantidadSegunda = 0;
		int cantidadInservible = 0;
		int cantidadSinClasificar = 0;
		int cantidadTotal = pallets.size();
		
		for (Pallet palletActual : pallets) {
			String clasificacion = palletActual.getClasificacionPallet();
			
			if(clasificacion == null || clasificacion.isEmpty()){
				cantidadSinClasificar++;
			}
			else if(clasificacion.equalsIgnoreCase(ClasificacionPallet.PRIMERA)){
				cantidadPrimera++;
			}else if(clasificacion.equalsIgnoreCase(ClasificacionPallet.SEGUNDA)){
				cantidadSegunda++;
			}else{
				cantidadInservible++;
			}
		}
		
		Map<String, Float> clasificacionPalletMap = new HashMap<String, Float>();
		
		if(cantidadPrimera>0){
			clasificacionPalletMap.put(ClasificacionPallet.PRIMERA, (float) cantidadPrimera/cantidadTotal );
		}
		if(cantidadSegunda>0){
			clasificacionPalletMap.put(ClasificacionPallet.SEGUNDA, (float) cantidadSegunda/cantidadTotal );
		}
		if(cantidadInservible>0){
			clasificacionPalletMap.put(ClasificacionPallet.INSERVIBLE, (float) cantidadInservible/cantidadTotal );
		}
		if(cantidadSinClasificar>0){
			clasificacionPalletMap.put(ClasificacionPallet.SIN_CLASIFICAR, (float) cantidadSinClasificar/cantidadTotal );
		}
				
		return clasificacionPalletMap;
	}


	public Map<String, Map<String, Integer>> obtenerPalletPorMaquina(){
		
		Map<String, Map<String, Integer>> mapaPalletMaquina = new HashMap<String, Map<String,Integer>>();
		
		try {
			PreparedStatement getComposicionPalletsSt = ConnectionFactory.getConnection().
							prepareStatement("select DESCRIPCION,CLASIFICACION,count(*) from pallet, maquina m " +
													" where m.id = id_maquina and " +
													" CLASIFICACION is not null group by DESCRIPCION,CLASIFICACION");
					
			ResultSet r = getComposicionPalletsSt.executeQuery();

			while(r.next()){
				String claveMaquina = r.getString(1);
				
				Map<String, Integer> mapaClasificacionPalletCantidad = mapaPalletMaquina.get(claveMaquina);
				
				if(mapaClasificacionPalletCantidad == null){
					mapaClasificacionPalletCantidad = new HashMap<String, Integer>();
				}
				mapaClasificacionPalletCantidad.put(r.getString(2), r.getInt(3));
				
				mapaPalletMaquina.put(claveMaquina, mapaClasificacionPalletCantidad);
			}
			r.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
			
		return mapaPalletMaquina;
		
	}
	
	
	
	public Map<String,Long> obtenerComposicionDePallet(Pallet pallet){
		
		Map<String,Long> mapaComposicion = new HashMap<String, Long>();
		
		try {
			PreparedStatement getComposicionPalletsSt = ConnectionFactory.getConnection().
							prepareStatement("select CLASIFICACION,count(*) from pallet" +
													" where ID = ? group by CLASIFICACION");
					
			getComposicionPalletsSt.setLong(1, pallet.getId());
			
			ResultSet r = getComposicionPalletsSt.executeQuery();

			while(r.next()){
				mapaComposicion.put(r.getString(1), r.getLong(2));
			}
			r.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return mapaComposicion;
	}

		
	public void actualizarClasificacionDePallet(Long idPallet,String clasificacion){
		
		try {
			PreparedStatement updatePalletsSt = ConnectionFactory.getConnection().
							prepareStatement("update pallet set CLASIFICACION = ? where ID = ?");
					
			updatePalletsSt.setString(1, clasificacion);
			updatePalletsSt.setLong(2, idPallet);
			
			updatePalletsSt.executeUpdate();
			
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	
}
